package com.xuecheng.media.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import com.xuecheng.base.expection.XueChengPlusException;
import com.xuecheng.base.model.PageParams;
import com.xuecheng.base.model.PageResult;
import com.xuecheng.base.model.RestResponse;
import com.xuecheng.media.mapper.MediaFilesMapper;
import com.xuecheng.media.mapper.MediaProcessMapper;
import com.xuecheng.media.model.dto.QueryMediaParamsDto;
import com.xuecheng.media.model.dto.UploadFileParamsDto;
import com.xuecheng.media.model.dto.UploadFileResultDto;
import com.xuecheng.media.model.po.MediaFiles;
import com.xuecheng.media.model.po.MediaProcess;
import com.xuecheng.media.service.MediaFileService;
import io.minio.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.compress.utils.IOUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.*;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

/**
 * @author Mr.M
 * @version 1.0
 * @description TODO
 * @date 2022/9/10 8:58
 */
@Service
@Slf4j
public class MediaFileServiceImpl implements MediaFileService {

    @Autowired
    MediaFilesMapper mediaFilesMapper;

    @Autowired
    MinioClient minioClient;

    @Autowired
    MediaFileService currentProxy;

    @Autowired
    MediaProcessMapper mediaProcessMapper;

    // 存储普通文件
    @Value("${minio.bucket.files}")
    private String bucket_mediaFiles;
    // 存储视频
    @Value("${minio.bucket.videofiles}")
    private String bucket_video;


    /**
     * 查询文件信息
     *
     * @param companyId           机构id
     * @param pageParams          分页参数
     * @param queryMediaParamsDto 查询条件
     * @return 文件信息List
     */
    @Override
    public PageResult<MediaFiles> queryMediaFiels(Long companyId, PageParams pageParams, QueryMediaParamsDto queryMediaParamsDto) {

        // 构建查询条件对象
        LambdaQueryWrapper<MediaFiles> queryWrapper = new LambdaQueryWrapper<>();

        // 分页对象
        Page<MediaFiles> page = new Page<>(pageParams.getPageNo(), pageParams.getPageSize());
        // 查询数据内容获得结果
        Page<MediaFiles> pageResult = mediaFilesMapper.selectPage(page, queryWrapper);
        // 获取数据列表
        List<MediaFiles> list = pageResult.getRecords();
        // 获取数据总数
        long total = pageResult.getTotal();
        // 构建结果集
        PageResult<MediaFiles> mediaListResult = new PageResult<>(list, total, pageParams.getPageNo(), pageParams.getPageSize());
        return mediaListResult;

    }

    /**
     * 上传普通文件
     *
     * @param companyId           机构名称
     * @param uploadFileParamsDto 文件信息
     * @param localFilePath       文件本地路径
     * @return UploadFileResultDto
     */

    @Override
    public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, String localFilePath) {

        // 文件名
        String filename = uploadFileParamsDto.getFilename();
        // 先得到扩展名
        String extension = filename.substring(filename.lastIndexOf("."));
        // 得到 minneType
        String mineType = getMineType(extension);
        // 得到文件上传子目录
        String folderPath = getDefaultFolderPath();
        // 文件的MD5值
        String fileMd5 = getFileMd5(new File(localFilePath));
        // 文件名
        String objectName = folderPath + fileMd5 + extension;
        // 将文件上传到 minio
        boolean result = addMediaFilesToMinio(localFilePath, mineType, bucket_mediaFiles, objectName);
        if (!result) {
            XueChengPlusException.cast("上传文件到文件系统失败,请重试！");
        }
        // 将文件信息 保存到数据库
        MediaFiles mediaFiles = currentProxy.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_mediaFiles, objectName);
        if (mediaFiles == null) {
            XueChengPlusException.cast("文件上传后保存文件信息失败");
        }
        // 准备返回的对象
        UploadFileResultDto uploadFileResultDto = new UploadFileResultDto();
        BeanUtils.copyProperties(mediaFiles, uploadFileResultDto);
        return uploadFileResultDto;
    }

    /**
     * 检查文件是否存在数据库中
     *
     * @param fileMd5 文件的MD5值
     * @return Boolean false不存在, true存在
     */
    @Override
    public RestResponse<Boolean> checkFile(String fileMd5) {

        // 先查询数据库
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        if (mediaFiles != null) {
            // 如果数据库存在再查询 Minio

            // 构造查询参数 --bucket 桶名,object 文件路径
            String bucket = mediaFiles.getBucket();
            String filePath = mediaFiles.getFilePath();
            GetObjectArgs getObjectArgs = GetObjectArgs.builder()
                    .bucket(bucket)
                    .object(filePath)
                    .build();
            try {
                // 向minio获取该文件流
                InputStream inputStream = minioClient.getObject(getObjectArgs);
                if (inputStream != null) {
                    // 文件已存在
                    return RestResponse.success(true);
                }
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("checkFile()--文件在Minio不存在");
            }
            // 文件不存在
            return RestResponse.success(false);
        }

        // 数据库不存在
        return RestResponse.success(false);
    }

    /**
     * 分块文件上传前的检测
     *
     * @param fileMd5 上传文件的MD5
     * @param chunk   分块号
     * @return Boolean false不存在, true存在
     */
    @Override
    public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {

        // 分块存储路径MD5前两位为目录,chunk存储分块文件
        // 根据MD5拿到分块文件所在目录的路径
        String chunkFileFolderPath = getChunkFileFoldeePath(fileMd5);
        GetObjectArgs getObjectArgs = GetObjectArgs.builder()
                .bucket(bucket_video)
                .object(chunkFileFolderPath + chunkIndex)
                .build();
        try {
            // 向minio获取该文件流
            InputStream inputStream = minioClient.getObject(getObjectArgs);
            if (inputStream != null) {
                // 文件已存在
                return RestResponse.success(true);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 文件不存在
        return RestResponse.success(false);
    }

    /**
     * 上传分块文件
     *
     * @param absolutePath 分块文件本地路径
     * @param fileMd5      分块文件MD5
     * @param chunk        分块号
     * @return Boolean false失败 ture成功
     */
    @Override
    public RestResponse uploadChunk(String fileMd5, int chunk, String absolutePath) {

        // 获取文件类型
        String mineType = getMineType(null);
        // 获取分块上传目录的路径
        String chunkFileFolderPath = getChunkFileFoldeePath(fileMd5) + chunk;
        // 上传分块文件
        boolean result = addMediaFilesToMinio(absolutePath, mineType, bucket_video, chunkFileFolderPath);
        if (!result) {
            return RestResponse.validfail(false, "上传分块文件失败");
        }
        log.info("上传分块文件成功Md5 = " + fileMd5);
        return RestResponse.success(true);
    }

    /**
     * 合并分块文件
     *
     * @param companyId           机构id
     * @param fileMd5             文件md5
     * @param chunkTotal          分块总和
     * @param uploadFileParamsDto 文件信息
     * @return com.xuecheng.base.model.RestResponse
     * @description 合并分块
     * @author Mr.M
     * @date 2022/9/13 15:56
     */
    @Override
    public RestResponse mergechunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto) {

        // 找到分块文件,调用minio的SDK合并分块文件
        String chunkFileFolderPath = getChunkFileFoldeePath(fileMd5);
        // 指定分块文件信息
        List<ComposeSource> composeSources = new ArrayList<>();
        for (int i = 0; i < chunkTotal; i++) {
            ComposeSource build = ComposeSource.builder()
                    .bucket(bucket_video)
                    .object(chunkFileFolderPath + i)
                    .build();
            composeSources.add(build);
        }
        // 拿到扩展名
        String filename = uploadFileParamsDto.getFilename();
        String extension = filename.substring(filename.lastIndexOf("."));
        // 合并后文件的objectName
        String objectName = getFilePathByMd5(fileMd5, extension);

        // ========== 合并分块文件 ==========
        try {
            ComposeObjectArgs build = ComposeObjectArgs.builder()
                    .bucket(bucket_video) // 桶
                    .object(objectName) // 指定合并之后的路径和文件名
                    .sources(composeSources)   // 分块文件的的集合
                    .build();
            // 合并分块文件方法
            minioClient.composeObject(build);
            log.info("合并分块数据成功,bucker:{},objectNmae:{}",
                    bucket_video, objectName);
        } catch (Exception e) {
            log.info("合并分块数据失败,bucker:{},objectNmae:{},错误信息:{}",
                    bucket_video, objectName, e.getMessage());
            return RestResponse.validfail(false, "合并文件出错");
        }

        // 校验合并后的文件和源文件是否一致
        // try {
        //     // 获取合并文件的MD5值
        //     StatObjectArgs statObjectArgs = StatObjectArgs.builder()
        //             .bucket(bucket_video)
        //             .object(objectName)
        //             .build();
        //     StatObjectResponse stat = minioClient.statObject(statObjectArgs);
        //     String minioMergeFileMD5 = stat.etag();
        //     // 校验MD5
        //     if (minioMergeFileMD5 == null || !(fileMd5.equals(minioMergeFileMD5))) {
        //         return RestResponse.validfail(false, "合并文件出错");
        //     }
        // } catch (Exception e) {
        //     log.info("合并文件失败,MD5值不相等,bucker:{},objectNmae:{},错误信息:{}",
        //             bucket_video, objectName, e.getMessage());
        // }

        // ========== 校验合并后的文件和源文件的MD5是否一致,一致视频才上传成功 ==========
        // 下载在合并后的文件
        File file = downloadFileFromMinIO(bucket_video, objectName);
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            // 计算合并之后文件流的 MD5
            String mergeFileMD5 = DigestUtils.md5Hex(fileInputStream);
            // 比较原始文件的md5和minio合并之后的MD5
            if (!fileMd5.equals(mergeFileMD5)) {

                log.info("合并文件失败,MD5值不相等,bucker:{},objectNmae:{},原始文件:{},合并文件:{}",
                        bucket_video, objectName, fileMd5, mergeFileMD5);
                return RestResponse.validfail(false, "文件校验失败");
            }
        } catch (Exception e) {
            return RestResponse.validfail(false, "文件校验失败");
        }
        // 设置文件大小
        uploadFileParamsDto.setFileSize(file.length());
        // ========== 将文件信息入库 ==========
        MediaFiles mediaFiles = currentProxy.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_video, objectName);
        if (mediaFiles == null) {
            return RestResponse.validfail(false, "文件入库失败");
        }
        // ========== 清理分块文件 ==========
        clearChunkFiles(chunkTotal, chunkFileFolderPath);

        return RestResponse.success(true);
    }

    /**
     * 清除分块文件
     *
     * @param chunkTotal          分块总数
     * @param chunkFileFolderPath 分块文件路径
     */
    private void clearChunkFiles(int chunkTotal, String chunkFileFolderPath) {
        List<DeleteObject> objects = new LinkedList<>();
        for (int i = 0; i < chunkTotal; i++) {
            // 指定要删除分块文件的路径
            objects.add(new DeleteObject(chunkFileFolderPath + i));
        }
        // 指定删除分块文件的信息
        RemoveObjectsArgs removeObjectsArgs = RemoveObjectsArgs.builder()
                .bucket(bucket_video)
                .objects(objects)
                .build();
        // 删除分块文件
        try {
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(removeObjectsArgs);
            for (Result<DeleteError> result : results) {
                DeleteError error = result.get();
                log.info("删除分块信息失败,objectName:{},错误信息:{}", error.objectName(), error.message());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 将文件上传到minio
     *
     * @param localFilePath 文件本地路径
     * @param minmeType     媒体类型
     * @param bucket        桶
     * @param objectName    文件名
     * @return boolean
     */
    public boolean addMediaFilesToMinio(String localFilePath, String minmeType, String bucket, String objectName) {

        try {
            UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
                    .bucket(bucket) // 桶
                    .filename(localFilePath) // 指定本地文件路径
                    .object(objectName) // 对象名 放在子目录下
                    .contentType(minmeType) // 设置媒体文件类型
                    .build();
            // 上传文件
            minioClient.uploadObject(uploadObjectArgs);
            log.error("上传文件成功,bucket:{},objectName:{}", bucket, objectName);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("上传文件出错,bucket:{},objectName:{},错误信息:{}", bucket, objectName, e.getMessage());
            return false;
        }
    }

    /**
     * 从minio下载文件
     *
     * @param bucket     桶
     * @param objectName 对象名称
     * @return 下载后的文件
     */
    public File downloadFileFromMinIO(String bucket, String objectName) {
        // todo:输入输出流
        // 临时文件
        File minioFile = null;
        FileOutputStream outputStream = null;
        try {
            InputStream stream = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucket)
                    .object(objectName)
                    .build());
            // 创建临时文件
            minioFile = File.createTempFile("minio", ".merge");
            outputStream = new FileOutputStream(minioFile);
            IOUtils.copy(stream, outputStream);
            return minioFile;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    /**
     * 根据扩展名获取mimeType
     *
     * @param extension 扩展名
     * @return 文件类型 mimeType
     */
    private String getMineType(String extension) {

        if (extension == null) {
            extension = "";
        }
        // 获取扩展名对应的MIME 类型
        ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(extension);
        // 如果找不到确切的 MIME 类型，就会使用这个默认值。
        String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE; // 通用mimeType字节流
        if (extensionMatch != null) {
            mimeType = extensionMatch.getMimeType();
        }
        return mimeType;
    }

    /**
     * 获取文件默认存储目录路径 年/月/日
     *
     * @return 返回目录根据当前日期
     */
    private String getDefaultFolderPath() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String folder = sdf.format(new Date()).replace("-", "/") + "/";
        return folder;
    }

    /**
     * 获取文件的md5值
     *
     * @param file 文件
     * @return 文件的md5值
     */
    private String getFileMd5(File file) {
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            String fileMd5 = org.springframework.util.DigestUtils.md5DigestAsHex(fileInputStream);
            return fileMd5;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("获取上传文件md5值失败,错误信息:{}", e.getMessage());
            return null;
        }
    }

    /**
     * 保存文件信息到数据库
     *
     * @param companyId           机构id
     * @param fileMd5             文件md5值
     * @param uploadFileParamsDto 上传文件的信息
     * @param bucket              桶
     * @param objectName          对象名称
     * @return 上传的文件信息 MediaFiles
     */
    @Transactional
    public MediaFiles addMediaFilesToDb(Long companyId, String fileMd5, UploadFileParamsDto uploadFileParamsDto, String bucket, String objectName) {
        // 从数据库查询文件
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        if (mediaFiles == null) {
            mediaFiles = new MediaFiles();
            // 拷贝基本信息
            BeanUtils.copyProperties(uploadFileParamsDto, mediaFiles);
            mediaFiles.setId(fileMd5);
            mediaFiles.setFileId(fileMd5);
            mediaFiles.setCompanyId(companyId);
            mediaFiles.setUrl("/" + bucket + "/" + objectName);
            mediaFiles.setBucket(bucket);
            mediaFiles.setFilePath(objectName);
            mediaFiles.setCreateDate(LocalDateTime.now());
            mediaFiles.setAuditStatus("002003");
            mediaFiles.setStatus("1");
            // 保存文件信息到文件表
            int insert = mediaFilesMapper.insert(mediaFiles);
            if (insert <= 0) {
                log.error("保存文件信息到数据库失败,{}", mediaFiles);
                return null;
            }
            log.debug("保存文件信息到数据库成功,文件名:{},桶:{},MD5:{}", mediaFiles.getFilename(), mediaFiles.getBucket(), fileMd5);
        }

        // 记录待处理任务
        addWaitingTask(mediaFiles);
        return mediaFiles;

    }

    /**
     * 添加待处理任务
     *
     * @param mediaFiles 媒资文件信息
     */
    private void addWaitingTask(MediaFiles mediaFiles) {

        // 获取文件的mimeType
        String filename = mediaFiles.getFilename();
        // 获取文件扩展名
        String extension = filename.substring(filename.lastIndexOf(".") + 1);
        String mineType = getMineType(extension);
        if ("video/x-msvideo".equals(mineType)) {
            // avi文件
            MediaProcess mediaProcess = new MediaProcess();
            BeanUtils.copyProperties(mediaFiles, mediaProcess);
            mediaProcess.setStatus("1"); // 未处理
            mediaProcess.setCreateDate(LocalDateTime.now());
            mediaProcess.setFailCount(0);
            mediaProcess.setUrl(null);

            mediaProcessMapper.insert(mediaProcess);
        }
    }

    /**
     * 根据文件的Md5返回,Md5前两个字母的2级目录
     *
     * @param fileMd5 文件的MD5
     * @return 目录
     */
    private String getChunkFileFoldeePath(String fileMd5) {
        return fileMd5.substring(0, 1) + "/" +
                fileMd5.substring(1, 2) + "/" +
                "chunk" + "/";
    }

    /**
     * 得到合并后的文件的地址
     *
     * @param fileMd5 文件id即md5值
     * @param fileExt 文件扩展名
     * @return
     */
    private String getFilePathByMd5(String fileMd5, String fileExt) {
        return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + fileMd5 + fileExt;
    }

}
